unit Sperre;

interface

Uses Classes;

// ******************************************************************
// *****                        TSperre                        ******
// ******************************************************************


Type TSperre = class(TObject)
       Sperre : TList;

       Constructor Create(AnzahlDNAs:Integer;Planung:TObject);
       Constructor Create_Copy( AlteSperre:TSperre );
       Destructor Destroy; override;
       Procedure NummerSperren( Klasse, TeamInKlasse, Nummer:Integer);
       Function NummerLesen( Klasse, TeamInKlasse:Integer):Integer;
       Function Gesperrt( Klasse, TeamInKlasse, Nr:Integer):Boolean;
       Function KombinationErlaubt( Klasse1, TeamInKlasse1, Nr1, Klasse2, TeamInKlasse2, Nr2:Integer):Boolean;
       Function KombinationUnveraenderbar( Klasse1, TeamInKlasse1, Nr1, Klasse2, TeamInKlasse2, Nr2:Integer):Boolean;
       Function AnzahlGene( Klasse:Integer):Integer;
     End;

implementation

Uses Mxarrays, Planung;

// ******************************************************************
// ******************************************************************
// *****                        TSperre                        ******
// ******************************************************************
// ******************************************************************

Constructor TSperre.Create(AnzahlDNAs:Integer;Planung:TObject);
Var T, I     : Integer;
    SperrDNA : TIntArray;
Begin
 Sperre := TList.Create;
 For T := 1 to AnzahlDNAs Do
  Begin
   SperrDNA := TIntArray.Create( TTerminplanung(Planung).Klasse( T-1 ).SystemTeamanzahl, 0 );
   For I := 0 To SperrDNA.Capacity-1 Do SperrDNA.PutItem( I, -1 );
   Sperre.Add( SperrDNA );
 End;
End;

Constructor TSperre.Create_Copy( AlteSperre:TSperre );
Var T, I     : Integer;
    SperrDNA : TIntArray;
Begin
 Sperre := TList.Create;
 For T := 0 To AlteSperre.Sperre.Count-1 Do
  Begin
   SperrDNA := TIntArray.Create( TIntArray(AlteSperre.Sperre[T]).Capacity , 0 );
   For I := 0 To TIntArray(AlteSperre.Sperre[T]).Count-1 Do
    SperrDNA.PutItem( I, TIntArray(AlteSperre.Sperre[T]).GetItem( I ) );
   Sperre.Add( SperrDNA );
  End;
End;

Destructor TSperre.Destroy;
Var T : Integer;
Begin
 While Sperre.Count > 0 Do
  Begin
   TIntArray(Sperre[0]).Free;
   Sperre.Delete( 0 );
  End;
 Sperre.Free;
End;

Procedure TSperre.NummerSperren( Klasse, TeamInKlasse, Nummer:Integer);
Begin
 If ( Klasse >= 0 )  And ( TeamInKlasse >= 0 ) then
  TIntArray( Sperre.Items[Klasse]).PutItem( TeamInKlasse, Nummer );
End;

Function TSperre.NummerLesen( Klasse, TeamInKlasse:Integer):Integer;
Begin
  NummerLesen := -1;
  If ( Klasse >= 0 ) And ( TeamInKlasse >= 0 ) Then
    NummerLesen := TIntArray( Sperre.Items[Klasse]).GetItem( TeamInKlasse );
End;

Function TSperre.Gesperrt( Klasse, TeamInKlasse, Nr:Integer):Boolean;
Var S, Pos   : Integer;
    IntArray : TIntArray;
Begin
 Gesperrt := False;
 S := -1;
 If ( ( Klasse >= 0 ) And ( TeamInKlasse >= 0 ) ) Then
  Begin
   IntArray := TIntArray( Sperre.Items[Klasse]);
   S := IntArray.GetItem( TeamInKlasse );
   Pos := IntArray.IndexOf( Nr );
   If ( ( S <> -1 ) And ( S <> Nr ) ) Or ( (Pos > -1 ) And ( Pos <> TeamInKlasse ) ) then
    Gesperrt := True;
  End;
End;

Function TSperre.KombinationErlaubt( Klasse1, TeamInKlasse1, Nr1, Klasse2, TeamInKlasse2, Nr2:Integer):Boolean;
Begin
 KombinationErlaubt := ( Not Gesperrt( Klasse1, TeamInKlasse1, Nr1 ) ) And
                       ( Not Gesperrt( Klasse2, TeamInKlasse2, Nr2 ) ) ;
End;

Function TSperre.KombinationUnveraenderbar( Klasse1, TeamInKlasse1, Nr1, Klasse2, TeamInKlasse2, Nr2:Integer):Boolean;
Begin
 KombinationUnveraenderbar := ( ( Nr1 <> -1 ) And ( Klasse1 <> -1 ) And ( TeamInKlasse1 <> -1) ) And
                              ( ( ( Klasse2 = -1 ) And ( TeamInKlasse2 = -1) ) Or
                                ( ( Nr2 <> -1 ) And ( Klasse2 <> -1 ) And ( TeamInKlasse2 <> -1) ) );
//    ( ( Nr1 <> -1 ) And Gesperrt( Klasse1, TeamInKlasse1, Nr1 ) ) And
//    ( ( ( Klasse2 = -1 ) And ( TeamInKlasse2 = -1) ) Or
//      ( ( Nr2 <> -1 ) And Gesperrt( Klasse2, TeamInKlasse2, Nr2 ) ) );
End;

Function TSperre.AnzahlGene( Klasse:Integer):Integer;
Begin
 AnzahlGene := TIntArray(Sperre[ Klasse ]).Capacity;
End;


end.
